home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_urllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  20KB  |  548 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Regresssion tests for urllib'''
  5. import urllib
  6. import httplib
  7. import unittest
  8. from test import test_support
  9. import os
  10. import mimetools
  11. import tempfile
  12. import StringIO
  13.  
  14. def hexescape(char):
  15.     '''Escape char as RFC 2396 specifies'''
  16.     hex_repr = hex(ord(char))[2:].upper()
  17.     if len(hex_repr) == 1:
  18.         hex_repr = '0%s' % hex_repr
  19.     
  20.     return '%' + hex_repr
  21.  
  22.  
  23. class urlopen_FileTests(unittest.TestCase):
  24.     '''Test urlopen() opening a temporary file.
  25.  
  26.     Try to test as much functionality as possible so as to cut down on reliance
  27.     on connecting to the Net for testing.
  28.  
  29.     '''
  30.     
  31.     def setUp(self):
  32.         '''Setup of a temp file to use for testing'''
  33.         self.text = 'test_urllib: %s\n' % self.__class__.__name__
  34.         FILE = file(test_support.TESTFN, 'wb')
  35.         
  36.         try:
  37.             FILE.write(self.text)
  38.         finally:
  39.             FILE.close()
  40.  
  41.         self.pathname = test_support.TESTFN
  42.         self.returned_obj = urllib.urlopen('file:%s' % self.pathname)
  43.  
  44.     
  45.     def tearDown(self):
  46.         '''Shut down the open object'''
  47.         self.returned_obj.close()
  48.         os.remove(test_support.TESTFN)
  49.  
  50.     
  51.     def test_interface(self):
  52.         for attr in ('read', 'readline', 'readlines', 'fileno', 'close', 'info', 'geturl', '__iter__'):
  53.             self.assert_(hasattr(self.returned_obj, attr), 'object returned by urlopen() lacks %s attribute' % attr)
  54.         
  55.  
  56.     
  57.     def test_read(self):
  58.         self.assertEqual(self.text, self.returned_obj.read())
  59.  
  60.     
  61.     def test_readline(self):
  62.         self.assertEqual(self.text, self.returned_obj.readline())
  63.         self.assertEqual('', self.returned_obj.readline(), 'calling readline() after exhausting the file did not return an empty string')
  64.  
  65.     
  66.     def test_readlines(self):
  67.         lines_list = self.returned_obj.readlines()
  68.         self.assertEqual(len(lines_list), 1, 'readlines() returned the wrong number of lines')
  69.         self.assertEqual(lines_list[0], self.text, 'readlines() returned improper text')
  70.  
  71.     
  72.     def test_fileno(self):
  73.         file_num = self.returned_obj.fileno()
  74.         self.assert_(isinstance(file_num, int), 'fileno() did not return an int')
  75.         self.assertEqual(os.read(file_num, len(self.text)), self.text, 'Reading on the file descriptor returned by fileno() did not return the expected text')
  76.  
  77.     
  78.     def test_close(self):
  79.         self.returned_obj.close()
  80.  
  81.     
  82.     def test_info(self):
  83.         self.assert_(isinstance(self.returned_obj.info(), mimetools.Message))
  84.  
  85.     
  86.     def test_geturl(self):
  87.         self.assertEqual(self.returned_obj.geturl(), self.pathname)
  88.  
  89.     
  90.     def test_iter(self):
  91.         for line in self.returned_obj.__iter__():
  92.             self.assertEqual(line, self.text)
  93.         
  94.  
  95.  
  96.  
  97. class urlopen_HttpTests(unittest.TestCase):
  98.     '''Test urlopen() opening a fake http connection.'''
  99.     
  100.     def fakehttp(self, fakedata):
  101.         
  102.         class FakeSocket(StringIO.StringIO):
  103.             
  104.             def sendall(self, str):
  105.                 pass
  106.  
  107.             
  108.             def makefile(self, mode, name):
  109.                 return self
  110.  
  111.             
  112.             def read(self, amt = None):
  113.                 if self.closed:
  114.                     return ''
  115.                 
  116.                 return StringIO.StringIO.read(self, amt)
  117.  
  118.             
  119.             def readline(self, length = None):
  120.                 if self.closed:
  121.                     return ''
  122.                 
  123.                 return StringIO.StringIO.readline(self, length)
  124.  
  125.  
  126.         
  127.         class FakeHTTPConnection(httplib.HTTPConnection):
  128.             
  129.             def connect(self):
  130.                 self.sock = FakeSocket(fakedata)
  131.  
  132.  
  133.         if not httplib.HTTP._connection_class == httplib.HTTPConnection:
  134.             raise AssertionError
  135.         httplib.HTTP._connection_class = FakeHTTPConnection
  136.  
  137.     
  138.     def unfakehttp(self):
  139.         httplib.HTTP._connection_class = httplib.HTTPConnection
  140.  
  141.     
  142.     def test_read(self):
  143.         self.fakehttp('Hello!')
  144.         
  145.         try:
  146.             fp = urllib.urlopen('http://python.org/')
  147.             self.assertEqual(fp.readline(), 'Hello!')
  148.             self.assertEqual(fp.readline(), '')
  149.         finally:
  150.             self.unfakehttp()
  151.  
  152.  
  153.  
  154.  
  155. class urlretrieve_FileTests(unittest.TestCase):
  156.     '''Test urllib.urlretrieve() on local files'''
  157.     
  158.     def setUp(self):
  159.         self.tempFiles = []
  160.         self.registerFileForCleanUp(test_support.TESTFN)
  161.         self.text = 'testing urllib.urlretrieve'
  162.         
  163.         try:
  164.             FILE = file(test_support.TESTFN, 'wb')
  165.             FILE.write(self.text)
  166.             FILE.close()
  167.         finally:
  168.             
  169.             try:
  170.                 FILE.close()
  171.             except:
  172.                 pass
  173.  
  174.  
  175.  
  176.     
  177.     def tearDown(self):
  178.         for each in self.tempFiles:
  179.             
  180.             try:
  181.                 os.remove(each)
  182.             continue
  183.             continue
  184.  
  185.         
  186.  
  187.     
  188.     def constructLocalFileUrl(self, filePath):
  189.         return 'file://%s' % urllib.pathname2url(os.path.abspath(filePath))
  190.  
  191.     
  192.     def createNewTempFile(self, data = ''):
  193.         '''Creates a new temporary file containing the specified data,
  194.         registers the file for deletion during the test fixture tear down, and
  195.         returns the absolute path of the file.'''
  196.         (newFd, newFilePath) = tempfile.mkstemp()
  197.         
  198.         try:
  199.             self.registerFileForCleanUp(newFilePath)
  200.             newFile = os.fdopen(newFd, 'wb')
  201.             newFile.write(data)
  202.             newFile.close()
  203.         finally:
  204.             
  205.             try:
  206.                 newFile.close()
  207.             except:
  208.                 pass
  209.  
  210.  
  211.         return newFilePath
  212.  
  213.     
  214.     def registerFileForCleanUp(self, fileName):
  215.         self.tempFiles.append(fileName)
  216.  
  217.     
  218.     def test_basic(self):
  219.         result = urllib.urlretrieve('file:%s' % test_support.TESTFN)
  220.         self.assertEqual(result[0], test_support.TESTFN)
  221.         self.assert_(isinstance(result[1], mimetools.Message), 'did not get a mimetools.Message instance as second returned value')
  222.  
  223.     
  224.     def test_copy(self):
  225.         second_temp = '%s.2' % test_support.TESTFN
  226.         self.registerFileForCleanUp(second_temp)
  227.         result = urllib.urlretrieve(self.constructLocalFileUrl(test_support.TESTFN), second_temp)
  228.         self.assertEqual(second_temp, result[0])
  229.         self.assert_(os.path.exists(second_temp), 'copy of the file was not made')
  230.         FILE = file(second_temp, 'rb')
  231.         
  232.         try:
  233.             text = FILE.read()
  234.             FILE.close()
  235.         finally:
  236.             
  237.             try:
  238.                 FILE.close()
  239.             except:
  240.                 pass
  241.  
  242.  
  243.         self.assertEqual(self.text, text)
  244.  
  245.     
  246.     def test_reporthook(self):
  247.         
  248.         def hooktester(count, block_size, total_size, count_holder = [
  249.             0]):
  250.             self.assert_(isinstance(count, int))
  251.             self.assert_(isinstance(block_size, int))
  252.             self.assert_(isinstance(total_size, int))
  253.             self.assertEqual(count, count_holder[0])
  254.             count_holder[0] = count_holder[0] + 1
  255.  
  256.         second_temp = '%s.2' % test_support.TESTFN
  257.         self.registerFileForCleanUp(second_temp)
  258.         urllib.urlretrieve(self.constructLocalFileUrl(test_support.TESTFN), second_temp, hooktester)
  259.  
  260.     
  261.     def test_reporthook_0_bytes(self):
  262.         report = []
  263.         
  264.         def hooktester(count, block_size, total_size, _report = report):
  265.             _report.append((count, block_size, total_size))
  266.  
  267.         srcFileName = self.createNewTempFile()
  268.         urllib.urlretrieve(self.constructLocalFileUrl(srcFileName), test_support.TESTFN, hooktester)
  269.         self.assertEqual(len(report), 1)
  270.         self.assertEqual(report[0][2], 0)
  271.  
  272.     
  273.     def test_reporthook_5_bytes(self):
  274.         report = []
  275.         
  276.         def hooktester(count, block_size, total_size, _report = report):
  277.             _report.append((count, block_size, total_size))
  278.  
  279.         srcFileName = self.createNewTempFile('x' * 5)
  280.         urllib.urlretrieve(self.constructLocalFileUrl(srcFileName), test_support.TESTFN, hooktester)
  281.         self.assertEqual(len(report), 2)
  282.         self.assertEqual(report[0][1], 8192)
  283.         self.assertEqual(report[0][2], 5)
  284.  
  285.     
  286.     def test_reporthook_8193_bytes(self):
  287.         report = []
  288.         
  289.         def hooktester(count, block_size, total_size, _report = report):
  290.             _report.append((count, block_size, total_size))
  291.  
  292.         srcFileName = self.createNewTempFile('x' * 8193)
  293.         urllib.urlretrieve(self.constructLocalFileUrl(srcFileName), test_support.TESTFN, hooktester)
  294.         self.assertEqual(len(report), 3)
  295.         self.assertEqual(report[0][1], 8192)
  296.         self.assertEqual(report[0][2], 8193)
  297.  
  298.  
  299.  
  300. class QuotingTests(unittest.TestCase):
  301.     '''Tests for urllib.quote() and urllib.quote_plus()
  302.  
  303.     According to RFC 2396 ("Uniform Resource Identifiers), to escape a
  304.     character you write it as \'%\' + <2 character US-ASCII hex value>.  The Python
  305.     code of ``\'%\' + hex(ord(<character>))[2:]`` escapes a character properly.
  306.     Case does not matter on the hex letters.
  307.  
  308.     The various character sets specified are:
  309.  
  310.     Reserved characters : ";/?:@&=+$,"
  311.         Have special meaning in URIs and must be escaped if not being used for
  312.         their special meaning
  313.     Data characters : letters, digits, and "-_.!~*\'()"
  314.         Unreserved and do not need to be escaped; can be, though, if desired
  315.     Control characters : 0x00 - 0x1F, 0x7F
  316.         Have no use in URIs so must be escaped
  317.     space : 0x20
  318.         Must be escaped
  319.     Delimiters : \'<>#%"\'
  320.         Must be escaped
  321.     Unwise : "{}|\\^[]`"
  322.         Must be escaped
  323.  
  324.     '''
  325.     
  326.     def test_never_quote(self):
  327.         do_not_quote = ''.join([
  328.             'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
  329.             'abcdefghijklmnopqrstuvwxyz',
  330.             '0123456789',
  331.             '_.-'])
  332.         result = urllib.quote(do_not_quote)
  333.         self.assertEqual(do_not_quote, result, 'using quote(): %s != %s' % (do_not_quote, result))
  334.         result = urllib.quote_plus(do_not_quote)
  335.         self.assertEqual(do_not_quote, result, 'using quote_plus(): %s != %s' % (do_not_quote, result))
  336.  
  337.     
  338.     def test_default_safe(self):
  339.         self.assertEqual(urllib.quote.func_defaults[0], '/')
  340.  
  341.     
  342.     def test_safe(self):
  343.         quote_by_default = '<>'
  344.         result = urllib.quote(quote_by_default, safe = quote_by_default)
  345.         self.assertEqual(quote_by_default, result, 'using quote(): %s != %s' % (quote_by_default, result))
  346.         result = urllib.quote_plus(quote_by_default, safe = quote_by_default)
  347.         self.assertEqual(quote_by_default, result, 'using quote_plus(): %s != %s' % (quote_by_default, result))
  348.  
  349.     
  350.     def test_default_quoting(self):
  351.         should_quote = [ chr(num) for num in range(32) ]
  352.         should_quote.append('<>#%"{}|\\^[]`')
  353.         should_quote.append(chr(127))
  354.         should_quote = ''.join(should_quote)
  355.         for char in should_quote:
  356.             result = urllib.quote(char)
  357.             self.assertEqual(hexescape(char), result, 'using quote(): %s should be escaped to %s, not %s' % (char, hexescape(char), result))
  358.             result = urllib.quote_plus(char)
  359.             self.assertEqual(hexescape(char), result, 'using quote_plus(): %s should be escapes to %s, not %s' % (char, hexescape(char), result))
  360.         
  361.         del should_quote
  362.         partial_quote = 'ab[]cd'
  363.         expected = 'ab%5B%5Dcd'
  364.         result = urllib.quote(partial_quote)
  365.         self.assertEqual(expected, result, 'using quote(): %s != %s' % (expected, result))
  366.         self.assertEqual(expected, result, 'using quote_plus(): %s != %s' % (expected, result))
  367.  
  368.     
  369.     def test_quoting_space(self):
  370.         result = urllib.quote(' ')
  371.         self.assertEqual(result, hexescape(' '), 'using quote(): %s != %s' % (result, hexescape(' ')))
  372.         result = urllib.quote_plus(' ')
  373.         self.assertEqual(result, '+', 'using quote_plus(): %s != +' % result)
  374.         given = 'a b cd e f'
  375.         expect = given.replace(' ', hexescape(' '))
  376.         result = urllib.quote(given)
  377.         self.assertEqual(expect, result, 'using quote(): %s != %s' % (expect, result))
  378.         expect = given.replace(' ', '+')
  379.         result = urllib.quote_plus(given)
  380.         self.assertEqual(expect, result, 'using quote_plus(): %s != %s' % (expect, result))
  381.  
  382.  
  383.  
  384. class UnquotingTests(unittest.TestCase):
  385.     '''Tests for unquote() and unquote_plus()
  386.  
  387.     See the doc string for quoting_Tests for details on quoting and such.
  388.  
  389.     '''
  390.     
  391.     def test_unquoting(self):
  392.         escape_list = []
  393.         for num in range(128):
  394.             given = hexescape(chr(num))
  395.             expect = chr(num)
  396.             result = urllib.unquote(given)
  397.             self.assertEqual(expect, result, 'using unquote(): %s != %s' % (expect, result))
  398.             result = urllib.unquote_plus(given)
  399.             self.assertEqual(expect, result, 'using unquote_plus(): %s != %s' % (expect, result))
  400.             escape_list.append(given)
  401.         
  402.         escape_string = ''.join(escape_list)
  403.         del escape_list
  404.         result = urllib.unquote(escape_string)
  405.         self.assertEqual(result.count('%'), 1, 'using quote(): not all characters escaped; %s' % result)
  406.         result = urllib.unquote(escape_string)
  407.         self.assertEqual(result.count('%'), 1, 'using unquote(): not all characters escaped: %s' % result)
  408.  
  409.     
  410.     def test_unquoting_parts(self):
  411.         given = 'ab%sd' % hexescape('c')
  412.         expect = 'abcd'
  413.         result = urllib.unquote(given)
  414.         self.assertEqual(expect, result, 'using quote(): %s != %s' % (expect, result))
  415.         result = urllib.unquote_plus(given)
  416.         self.assertEqual(expect, result, 'using unquote_plus(): %s != %s' % (expect, result))
  417.  
  418.     
  419.     def test_unquoting_plus(self):
  420.         given = 'are+there+spaces...'
  421.         expect = given
  422.         result = urllib.unquote(given)
  423.         self.assertEqual(expect, result, 'using unquote(): %s != %s' % (expect, result))
  424.         expect = given.replace('+', ' ')
  425.         result = urllib.unquote_plus(given)
  426.         self.assertEqual(expect, result, 'using unquote_plus(): %s != %s' % (expect, result))
  427.  
  428.  
  429.  
  430. class urlencode_Tests(unittest.TestCase):
  431.     '''Tests for urlencode()'''
  432.     
  433.     def help_inputtype(self, given, test_type):
  434.         """Helper method for testing different input types.
  435.  
  436.         'given' must lead to only the pairs:
  437.             * 1st, 1
  438.             * 2nd, 2
  439.             * 3rd, 3
  440.  
  441.         Test cannot assume anything about order.  Docs make no guarantee and
  442.         have possible dictionary input.
  443.  
  444.         """
  445.         expect_somewhere = [
  446.             '1st=1',
  447.             '2nd=2',
  448.             '3rd=3']
  449.         result = urllib.urlencode(given)
  450.         for expected in expect_somewhere:
  451.             self.assert_(expected in result, 'testing %s: %s not found in %s' % (test_type, expected, result))
  452.         
  453.         self.assertEqual(result.count('&'), 2, "testing %s: expected 2 '&'s; got %s" % (test_type, result.count('&')))
  454.         amp_location = result.index('&')
  455.         on_amp_left = result[amp_location - 1]
  456.         on_amp_right = result[amp_location + 1]
  457.         if on_amp_left.isdigit():
  458.             pass
  459.         self.assert_(on_amp_right.isdigit(), "testing %s: '&' not located in proper place in %s" % (test_type, result))
  460.         self.assertEqual(len(result), 5 * 3 + 2, 'testing %s: unexpected number of characters: %s != %s' % (test_type, len(result), 5 * 3 + 2))
  461.  
  462.     
  463.     def test_using_mapping(self):
  464.         self.help_inputtype({
  465.             '1st': '1',
  466.             '2nd': '2',
  467.             '3rd': '3' }, 'using dict as input type')
  468.  
  469.     
  470.     def test_using_sequence(self):
  471.         self.help_inputtype([
  472.             ('1st', '1'),
  473.             ('2nd', '2'),
  474.             ('3rd', '3')], 'using sequence of two-item tuples as input')
  475.  
  476.     
  477.     def test_quoting(self):
  478.         given = {
  479.             '&': '=' }
  480.         expect = '%s=%s' % (hexescape('&'), hexescape('='))
  481.         result = urllib.urlencode(given)
  482.         self.assertEqual(expect, result)
  483.         given = {
  484.             'key name': 'A bunch of pluses' }
  485.         expect = 'key+name=A+bunch+of+pluses'
  486.         result = urllib.urlencode(given)
  487.         self.assertEqual(expect, result)
  488.  
  489.     
  490.     def test_doseq(self):
  491.         given = {
  492.             'sequence': [
  493.                 '1',
  494.                 '2',
  495.                 '3'] }
  496.         expect = 'sequence=%s' % urllib.quote_plus(str([
  497.             '1',
  498.             '2',
  499.             '3']))
  500.         result = urllib.urlencode(given)
  501.         self.assertEqual(expect, result)
  502.         result = urllib.urlencode(given, True)
  503.         for value in given['sequence']:
  504.             expect = 'sequence=%s' % value
  505.             self.assert_(expect in result, '%s not found in %s' % (expect, result))
  506.         
  507.         self.assertEqual(result.count('&'), 2, "Expected 2 '&'s, got %s" % result.count('&'))
  508.  
  509.  
  510.  
  511. class Pathname_Tests(unittest.TestCase):
  512.     '''Test pathname2url() and url2pathname()'''
  513.     
  514.     def test_basic(self):
  515.         expected_path = os.path.join('parts', 'of', 'a', 'path')
  516.         expected_url = 'parts/of/a/path'
  517.         result = urllib.pathname2url(expected_path)
  518.         self.assertEqual(expected_url, result, 'pathname2url() failed; %s != %s' % (result, expected_url))
  519.         result = urllib.url2pathname(expected_url)
  520.         self.assertEqual(expected_path, result, 'url2pathame() failed; %s != %s' % (result, expected_path))
  521.  
  522.     
  523.     def test_quoting(self):
  524.         given = os.path.join('needs', 'quot=ing', 'here')
  525.         expect = 'needs/%s/here' % urllib.quote('quot=ing')
  526.         result = urllib.pathname2url(given)
  527.         self.assertEqual(expect, result, 'pathname2url() failed; %s != %s' % (expect, result))
  528.         expect = given
  529.         result = urllib.url2pathname(result)
  530.         self.assertEqual(expect, result, 'url2pathname() failed; %s != %s' % (expect, result))
  531.         given = os.path.join('make sure', 'using_quote')
  532.         expect = '%s/using_quote' % urllib.quote('make sure')
  533.         result = urllib.pathname2url(given)
  534.         self.assertEqual(expect, result, 'pathname2url() failed; %s != %s' % (expect, result))
  535.         given = 'make+sure/using_unquote'
  536.         expect = os.path.join('make+sure', 'using_unquote')
  537.         result = urllib.url2pathname(given)
  538.         self.assertEqual(expect, result, 'url2pathname() failed; %s != %s' % (expect, result))
  539.  
  540.  
  541.  
  542. def test_main():
  543.     test_support.run_unittest(urlopen_FileTests, urlopen_HttpTests, urlretrieve_FileTests, QuotingTests, UnquotingTests, urlencode_Tests, Pathname_Tests)
  544.  
  545. if __name__ == '__main__':
  546.     test_main()
  547.  
  548.